
/*
 * Classe principal do sistema
 * 
 * Ednei Leite da Silva
 * R.G.M.: 019250
 */
#ifndef INTERFACE_HPP
#define	INTERFACE_HPP


#include <biblioteca.h>
#include <banco.h>
#include <treeview_filter.h>
#include <treeview_firewall.h>

/**
 * Classe que define a janela principal
 */
class INTERFACE {
public:

    /* Widgets das janela principal e de login*/
    Gtk::Window cliente_fw;
    Gtk::Dialog dialog_login;


private:

    /* Widgets utilizados na iterface da janela de login */
    Gtk::Label *label_login;
    Gtk::HBox *hbox_login;
    Gtk::Entry user, senha;
    Gtk::Button okLogin, cancelar_login;
    /* Fim Widget da janela de login */

    /******************************************************************/

    /* Menu principal */
    Gtk::MenuBar *menubar;
    Gtk::MenuItem *menuitem_arquivo, *menuitem_sair;
    Gtk::MenuItem *menuitem_regras, *alterar, *excluir;
    Gtk::Menu *filemenu, *regras_menu;

    /* elementos principais da janela */
    Gtk::VBox principal, *elementos;
    Gtk::HBox *hbox;
    Gtk::Notebook notebook;
    Gtk::Label *label, status;

    /* Inicio - Widget's */
    Gtk::VBox vbox_tab;
    Gtk::Fixed elementos_tab;

    /* caixas de seleção */
    Gtk::ComboBoxText tabela, chain, alvo, opcao_alvo, interface_rede_tabela, modulo, argumento_modulo, protocolo, argumento_protocolo;

    /* Caixa de texto */
    Gtk::Entry parametros_opcao, endereco_origem, endereco_destino, porta_origem, porta_destino;
    Gtk::Entry parametros_modulo, parametros_protocolo;

    /* botões utilizadas para limitar valores inseridos no valor da porta */
    Gtk::SpinButton linha;
    Glib::RefPtr<Gtk::Adjustment> adj_linha;

    Gtk::CheckButton politica_padrao, not_protocolo, not_endereco_origem, not_endereco_destino;
    Gtk::CheckButton not_porta_origem, not_porta_destino, not_interface;
    Gtk::RadioButton entrada, saida;
    Gtk::Button inserir_regra, limpar_regra, recarregar_regras_firewall;

    /* elementos necessários para inserção da treeview */
    Gtk::ScrolledWindow scr_tab;
    treeview_firewall trfirewall;
    /* Fim - Widget's página regras do firewall */

    /***********************************************************************/

    /* Inicio - Widget's pagina Filtro de Pacotes*/
    Gtk::VBox vbox_fp;
    Gtk::Fixed elementos_fp;
    Gtk::ComboBoxText interface_rede_fp, filter_result, regra_fp;

    Gtk::SpinButton quant_fp;
    Glib::RefPtr<Gtk::Adjustment> adj_quant_fp;

    Gtk::Button ok_fp, exec_result_filter, create_by_row, delete_row;
    Gtk::HBox hbox_button, hbox_result_filter;

    Gtk::ScrolledWindow scr_filtro;
    treeview_filter trfilter;
    bool status_filtro;

    bool active_thread;
    Glib::Thread* thread;
    Glib::Dispatcher dispatcher;

    /* Fim - Widget's pagina Filtro de Pacotes*/

    /***********************************************************************/

    /* Descritor da conexão com o servidor*/
    int sock;

    /* Atributos que armazena dados para conexão com servidor */
    string servidor_fw, usuario_fw, senha_fw;

    /* Atributos buffer auxiliar, e flag_linha que utilizada para armazenar o linha ao alterar regra */
    string buffer, flag_linha;

    /*
     * carregar: sinaliza que já esta sendo executada uma operação
     * desta forma evita problema ao disparar evento (change)
     * que pode ser confundido com evento de seleciona uma opção na combobox
     * uma vez que ao inserir elementos em uma combobox dispara este mesmo evento
     * serve de certa forma para indicar "ignorar evento"
     */
    bool carregar;

    /*
     * conectado: flag que sinaliza que cliente esta conectado ao servidor.
     * servidor_atualizado: flag que sinaliza se já foi atualizado com alterações
     */
    bool conectado, servidor_atualizado;

    /* Obejeto de conexão com o banco de dados */
    banco *bd;

    /*
     * Atributo utilizado para envio e recpção de mensagem ao servidor
     */
    char *msg;

public:

    /********** Cabeçalhos implementados em interface.cpp **********/

    INTERFACE(); //Método construtor

    ~INTERFACE(); //Método destrutor

    /**
     * Método que construi interface da aplicação
     */
    void construct_interface();

private:

    /*
     * Método que gera mensagens de alerta em geral
     * 
     * principal Mensagem principal
     * secundaria Mensagem secundaria
     * mensagem Tipo de Mensagem (Gtk::MESSAGE_ERROR, Gtk::MESSAGE_INFO, ...)
     * botao Tipo de botões da janela (Gtk::BUTTONS_OK, Gtk::BUTTONS_OK_CANCEL, ...)
     * Caixa de dialogo esteja solicitando uma confirmação retorna true se clicado em OK ou Sim
     * ou false caso clique em Cancelar ou  Não. Retorna false se for uma caixa de dialogo simples.
     */
    bool mensagem(string, string, Gtk::MessageType, Gtk::ButtonsType);

    /*
     * Método que limpa o conteudo na janela inserção de regras
     * após uma inserção, alteração ou alterção de uma regra padrão
     */
    void limpar_regras_firewall();

    /*
     * Método que manipula janela inserção de regras
     * para que possa alterar politica padrão
     * bloqueando os campos desnecessarios
     */
    void opcoes_gera_politica_padrao();

    /*
     * Inicio dos método que trata dados inseridos pelos usuário
     * e retorna se estiverem corretos
     */

    /*
     * Método que gera conteudo do alvo caso exista
     * caso contrario retorna string vazia
     */
    string get_parametros_opcao_alvo();

    /*
     * Método que retorna o endereço de origem
     */
    string get_endereco_origem();

    /*
     * Método que retorna endereço de destino
     */
    string get_endereco_destino();

    /*
     * Método que retorna interface de rede selecionada
     */
    string get_interface_rede_firewall();

    /*
     * Método que retorna i - se Saída ou o - se entrada
     */
    string get_interface_rede_saida_entrada();

    /*
     * Método que retorna parametros do modulos
     */
    string get_parametros_modulos();


    /***************** Fim cabeçalhos interface.cpp ****************/

    /************ Cabeçalhos implementados em login.cpp *************/

public:

    /**
     * Retorna informação se esta logado
     * @return Retorna TRUE se foi efetuado login. FALSE caso contrario.
     */
    bool logado();

private:
    /**
     * Método que encerra janela ao ser chamado
     */
    void cancelar_login_action();

    /**
     * Método virtual que implementa ação do botão okAction
     */
    void ok_login_action();

    /********************* Fim cabeçalhos login.cpp ******************/

    /********** Cabeçalhos implementados em aplicacaoFW.cpp **********/

    /*
     * Método que realização conexão com o servidor Firewall
     * 
     * user Usuário
     * senha Senha
     * servidor Endereço do servidor
     * Retorna TRUE se foi efetuado login. FALSE Caso contrario.
     */
    bool conectar_servidor(string, string, string);

    void download_regras_firewall();

    /*
     * Método que solicita as interfaces de rede do servidor
     */
    void get_interface();

    /*
     * Método que carrega tabelas "cadastradas" no sistema
     */
    void carrega_tabela();

    /*
     * Método que carrega chains correspondente da tabela selecionada
     */
    void carrega_chain();

    /*
     * Método que carrega target (alvo) correspondente
     * a tabela e ao chain selecionado
     */
    void carrega_target();

    /*
     * Método que carrega opção caso exista para 
     * a target selecionada
     */
    void carrega_option();

    /*
     * Método que habilita parametros da opção selecionada
     * esta opção referente a target
     */
    void habilita_parametros_option();

    /*
     * Método que carrega todos os protocolos disponivel no banco de dados
     */
    void carrega_protocolos();

    /*
     * Método que carrega todos os argumentos do protocolo
     */
    void carrega_argumentos_protocolo();

    /*
     * Método que verifica se para o argumento do protocolo
     * selecionado é necessário inserir parametros
     */
    void habilita_parametros_protocolo();

    /*
     * Método que carrega todos os modulos disponiveis
     */
    void carrega_modulos();

    /*
     * Método que carrega argumentos referentes ao modulo
     */
    void carrega_argumentos_mod();

    /*
     * Método que habilita radio button ao selecionar chain
     * evitando por exemplo:
     * * utilizar uma interface de saída para uma chain INPUT
     */
    void carrega_interface_rede();

    /*
     * Método que carrega regras utilizadas anteriormente
     * para a filtragem de pacotes
     */
    void carrega_regras_filtro();

    /*
     * Método que verifica se é uma operação de inserção
     * ou alteração de regras de firewall ou alteração da
     * política padrão
     */
    void insere_altera_regras_firewall();

    /*
     * Método utilizado para avaliar se os dados da opção do alvo
     * esta correta e verifica também se os paramentos do mesmo esta correto.
     * retorna true se os dados referente ao alvo estiverem corretos
     */
    bool avalia_opcao_alvo();

    /*
     * Método que valida a inserção de protocolo
     */
    bool valida_insercao_protocolo();

    /*
     * Método que verifica se os valores das
     * portas ou intervalos de portas estão corretos
     */
    bool valida_insercao_portas();

    /*
     * Método que verifica se os dados dos módulos estão corretos
     * retorna True se dados do modulo estiver correto
     */
    bool valida_insercao_modulo();

    /*
     * Método utilizado para verificar de determinada informação esta correta.
     * id_expressao Id's das expressoes regulares utilizada para pesquisar as expressoes para validar os dados
     * valor_verificar Valor que será validado
     * retorna true se os dados são validos
     */
    bool valida_dados_expressao_regular(const char *, const char *, const char *);

    /*
     * Método que avalia o intervalo de portas se
     * o valor "minimo" é menor que o "máximo"
     * 55:75 Valido
     * 75:55 Invalido
     */
    bool intervalo_portas(const char *);

    /*
     * Método que verifica se os endereços de origem e destino existem
     */
    bool verifica_endereco(const char *);

    /*
     * Método que verifica se os dados necessários para os
     * alvos dnat e snat (tabela nat) forma informados
     */
    bool verifica_portas_dnat_snat(const char *);

    /*
     * Caso sejá inserido paramtro nos alvos
     * REDIRECT ou MASQUERADE
     * verifica se foi selecionado um protocolo
     * e inserido portas de origem ou destino
     */
    bool verifica_portas_redirect_masquerade();

    /*
     * Método que verifica se regra de firewall existe
     * e se os dados são validos
     */
    bool existe_regra_firewall();

    /*
     * Método que altera politica padrão de tabela e chain
     */
    void alterar_politica_padrao_firewall();

    /*
     * Método utilizado para inserir uma nova
     * regra de firewall
     */
    void inserir_regra_firewall();

    /*
     * Método utilizado para capturar dados para edição
     * de regra de firewall e mostra-los na janela de edição
     */
    void get_alterar_regra_firewall();

    /* Método que altera regra selecionada */
    void alterar_regra_firewall();

    /* Método que remove a regra selecionada */
    void excluir_regra_firewall();

    /* Método que envia regras para o servidor firewall */
    void upload_regras_firewall();

    /*
     * Método que captura dados para filtragem e cria thead
     * para preencher a treeview com as informações dos dados capturados
     */
    void executa_filtro();

    /*
     * Método utilizado pela thread para preencher a treeview
     * filtro String com especificação do filtro de pacote
     * quantidade Quantidade de pacotes a ser capturado
     */
    void thread_filtro_pacotes(char *filtro, int quantidade);

    /*
     * Método despachante que reabilita janela de inserção de uma
     * nova regra de filtragem
     */
    void exec_dispatcher();

    /*
     * Método que extrai conteudo de uma mensagem
     * comeco Inicio da tag
     * fim Fim da tag
     * Retorna o conteudo dentro da tag. Ou vazio caso não encontre a tag.
     */
    string get_conteudo_msg(string msg, string comeco, string fim);

    /*
     * Método chamado ao clicar no botão encerrar
     * verifica se ouve alteração e solicita que altere dados
     */
    void encerrar();

    /*
     * Método que recebe dados da linha seleciona da treeview
     * e insere na janela de criação de regra do firewall
     */
    void create_by_row_filter();

    /* Método que exclui uma linha selecionada da treeview dos filtros de pacotes */
    void delete_row_filter();

    /* Método que filtra linha semelhentes segundo um valor da linha selecionada */
    void exec_filter_result();


    /***************** Fim cabeçalhos aplicacaoFW.cpp ****************/
};

#define SIZE_PP_MENSAGEM 20
#define SIZE_MENSAGEM 200

#endif	/* INTERFACE_HPP */

